
#include <stdio.h>
#include"DoublyLinkedList.h"

// 初始化链表
ListNode* ListInit()
{
	// 创建头节点
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	if (head == NULL)
	{
		perror("malloc fail 01");
		return NULL;
	}
	// 头节点的前驱和后继都指向自己，数据域设为-1
	head->_prev = head;
	head->_next = head;
	head->_data = -1;
	return head;
}
 
// 创建节点
ListNode* ListCreate(LTDataType x)
{
	// 申请新节点
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail 02");
		return NULL;
	}
	// 初始化新节点的前驱、后继和数据域
	newnode->_prev = NULL;
	newnode->_next = NULL;
	newnode->_data = x;
	return newnode;
}
 
// 打印链表
void ListPrint(ListNode* pHead)
{
	if (pHead == NULL)
	{
		printf("NULL");
	}
	else
	{
		ListNode* cur = pHead->_next;
		while (cur != pHead)
		{
			printf("%d->", cur->_data);
			cur = cur->_next;
		}
		printf("NULL");
	}
	printf("\n");
}
 
// 销毁链表
void ListDestory(ListNode** pHead)
{
	assert(*pHead); // 断言头节点不为空
	ListNode* cur = (*pHead)->_next;
	while (cur != *pHead)
	{
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(*pHead);
	*pHead = NULL;
}
 
// 尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead); // 断言头节点不为空
	ListNode* node = ListCreate(x);
	node->_prev = pHead->_prev;
	node->_next = pHead;
	pHead->_prev->_next = node;
	pHead->_prev = node;
}
 
// 尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead); // 断言头节点不为空
	assert(pHead->_next != pHead); // 断言链表不为空
	ListNode* delnode = pHead->_prev;
	delnode->_prev->_next = pHead;
	pHead->_prev = delnode->_prev;
	free(delnode);
	delnode = NULL;
}
 
// 头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead); // 断言头节点不为空
	ListNode* node = ListCreate(x);
	node->_prev = pHead;
	node->_next = pHead->_next;
	pHead->_next->_prev = node;
	pHead->_next = node;
}
 
// 头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead); // 断言头节点不为空
	ListNode* delnode = pHead->_next;
	delnode->_next->_prev = pHead;
	pHead->_next = delnode->_next;
	free(delnode);
	delnode = NULL;
}
 
// 查找节点
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead); // 断言头节点不为空
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		if (cur->_data == x)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}
 
// 指定位置之前插入节点
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos); // 断言位置节点不为空
	ListNode* node = ListCreate(x);
	node->_next = pos;
	node->_prev = pos->_prev;
	pos->_prev->_next = node;
	pos->_prev = node;
}
 
// 删除指定位置的节点
void ListErase(ListNode* pos)
{
	assert(pos); // 断言位置节点不为空
	pos->_next->_prev = pos->_prev;
	pos->_prev->_next = pos->_next;
	free(pos);
	pos = NULL;
}


ListNode* creatslist(ListNode* phead, int* arr, int size)
{
    struct ListNode* ptail = phead;
    for (int i = 0; i < size; i++)
    {
        struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
        if (newnode)
        {
            newnode->_data = arr[i];

            ptail->_next = newnode;
            phead->_prev = newnode;
            newnode->_next = phead;
            newnode->_prev = ptail;
        }
        else
        {
            return NULL;
        }
        ptail = ptail->_next;
    }
    return phead;
}

int main(int argc, char const *argv[])
{
    ListNode* sl = ListCreate(123);
    int arr[] = { 1,2,3,4,5 };
    creatslist(sl, arr, 5);
    ListPushBack(sl, 6);
    ListPrint(sl);
    ListPopBack(sl);
    ListPrint(sl);
    ListPushFront(sl, 0);
    ListPrint(sl);
    ListPopFront(sl);
    ListPrint(sl);
    ListInsert(ListFind(sl,3), 3);
    ListPrint(sl);
    ListErase(ListFind(sl,3));
    ListPrint(sl);
    ListDestory(&sl);
    ListPrint(sl);
    return 0;
}

 

